import { getFunctionData, getImageUrl } from '../utils/getdate.js'
import fetch from 'node-fetch'
import { render } from '../components/index.js'

// TextMsg可自行更改，其他照旧即可。
export class TextMsg extends plugin {
    constructor () {
        super({
            name: '[鸢尾花插件]番剧信息', // 插件名称
            dsc: '番剧信息查询', // 插件描述
            event: 'message', // 更多监听事件请参考下方的 Events
            priority: 5000, // 插件优先度，数字越小优先度越高
            rule: [
                {
                    reg: '^#?(今日番剧|番剧)$', // 正则表达式,有关正则表达式请自行百度
                    fnc: 'todayAnime' // 执行方法
                },
                {
                    reg: '^#?昨日番剧$',
                    fnc: 'yesterdayAnime'
                },
                {
                    reg: '^#?本周番剧$',
                    fnc: 'weeklyAnime'
                },
                {
                    reg: '^#?(周[一二三四五六日]|星期[一二三四五六日])番剧$',
                    fnc: 'weekdayAnime'
                }
            ]

        })
        this.task = {
            cron: this.BangumiConfig.PushTime,
            name: '今日番剧',
            fnc: () => this.pushAnime()
        }
        Object.defineProperty(this.task, 'log', { get: () => false })
    }

    get BangumiConfig () { return getFunctionData('Push', 'Push', '今日番剧') }

    // 执行方法1 - 今日番剧
    async todayAnime (e) {
        try {
            // 获取番剧数据
            const animeData = await this.getAnimeData('today')
            if (!animeData || animeData.length === 0) {
                logger.error('[今日番剧] 无法获取番剧数据')
                e.reply('无法获取番剧数据，请稍后再试')
                return true
            }
            
            // 背景图路径 - 相对于resources目录的路径
            const bgImagePath = 'gallery/114388636.webp'
            
            // 使用render.js渲染图片
            const img = await render('bgm/anime_list', {
                animeData: animeData,
                bgImagePath: bgImagePath,
                title: '今日番剧'
            }, {
                e: e
            })
            
            // 回复图片
            if (img) {
                await e.reply(img)
            }
            
            logger.info('[今日番剧] 图片渲染完成')
        } catch (error) {
            logger.error('无法获取番剧信息:', error.message)
            e.reply('无法访问API，请稍后再试')
        }

        return true
    }
    
    // 执行方法2 - 昨日番剧
    async yesterdayAnime (e) {
        try {
            // 获取昨日番剧数据
            const animeData = await this.getAnimeData('yesterday')
            if (!animeData || animeData.length === 0) {
                logger.error('[昨日番剧] 无法获取番剧数据')
                e.reply('无法获取番剧数据，请稍后再试')
                return true
            }
            
            // 背景图路径 - 相对于resources目录的路径
            const bgImagePath = 'gallery/114388636.webp'
            
            // 使用render.js渲染图片
            const img = await render('bgm/anime_list', {
                animeData: animeData,
                bgImagePath: bgImagePath,
                title: '昨日番剧'
            }, {
                e: e
            })
            
            // 回复图片
            if (img) {
                await e.reply(img)
            }
            
            logger.info('[昨日番剧] 图片渲染完成')
        } catch (error) {
            logger.error('无法获取番剧信息:', error.message)
            e.reply('无法访问API，请稍后再试')
        }

        return true
    }
    
    // 执行方法3 - 本周番剧
    async weeklyAnime (e) {
        try {
            // 获取本周番剧数据
            const weekData = await this.getAnimeData('week')
            if (!weekData || !weekData.length) {
                logger.error('[本周番剧] 无法获取番剧数据')
                e.reply('无法获取番剧数据，请稍后再试')
                return true
            }
            
            // 背景图路径 - 相对于resources目录的路径
            const bgImagePath = 'gallery/114388636.webp'
            
            // 使用render.js渲染图片
            const img = await render('bgm/anime_list', {
                weekGroups: weekData,
                bgImagePath: bgImagePath,
                title: '本周番剧'
            }, {
                e: e
            })
            
            // 回复图片
            if (img) {
                await e.reply(img)
            }
            
            logger.info('[本周番剧] 图片渲染完成')
        } catch (error) {
            logger.error('无法获取番剧信息:', error.message)
            e.reply('无法访问API，请稍后再试')
        }

        return true
    }
    
    // 执行方法4 - 按星期查询番剧
    async weekdayAnime (e) {
        try {
            // 从消息中提取星期几
            const weekdayMatch = e.msg.match(/(周|星期)([一二三四五六日])/);
            if (!weekdayMatch) {
                e.reply('无法识别星期信息，请使用"#周x番剧"或"#星期x番剧"的格式');
                return true;
            }
            
            // 将中文星期转换为数字（1-7，对应周一到周日）
            const weekdayMap = { '一': 1, '二': 2, '三': 3, '四': 4, '五': 5, '六': 6, '日': 7 };
            const weekdayNum = weekdayMap[weekdayMatch[2]];
            const weekdayCN = `星期${weekdayMatch[2]}`;
            
            // 获取特定星期的番剧数据
            const animeData = await this.getAnimeData(`weekday:${weekdayNum}`);
            if (!animeData || animeData.length === 0) {
                logger.error(`[${weekdayCN}番剧] 无法获取番剧数据`);
                e.reply(`无法获取${weekdayCN}番剧数据，请稍后再试`);
                return true;
            }
            
            // 背景图路径 - 相对于resources目录的路径
            const bgImagePath = 'gallery/114388636.webp';
            
            // 使用render.js渲染图片
            const img = await render('bgm/anime_list', {
                animeData: animeData,
                bgImagePath: bgImagePath,
                title: `${weekdayCN}番剧`
            }, {
                e: e
            });
            
            // 回复图片
            if (img) {
                await e.reply(img)
            }
            
            logger.info(`[${weekdayCN}番剧] 图片渲染完成`);
        } catch (error) {
            logger.error('无法获取番剧信息:', error.message);
            e.reply('无法访问API，请稍后再试');
        }

        return true;
    }

    // 推送番剧信息到群组
    async pushAnime (e) {
        if (!this.BangumiConfig.isAutoPush) { return false }

        try {
            // 获取番剧数据
            const animeData = await this.getAnimeData('today')
            if (!animeData || animeData.length === 0) {
                logger.error('[今日番剧] 无法获取番剧数据，取消推送')
                return true
            }
            
            // 背景图路径 - 相对于resources目录的路径
            const bgImagePath = 'gallery/114388636.webp'
            
            // 渲染图片并获取生成的图片路径
            const renderData = {
                animeData: animeData,
                bgImagePath: bgImagePath,
                title: '今日番剧',
                saveId: `bangumi_${Date.now()}`  // 生成唯一ID
            }
            
            // 一次性渲染图片
            const image = await render('bgm/anime_list', renderData, {})
            
            if (!image) {
                logger.error('[今日番剧] 图片渲染失败，取消推送')
                return true
            }
            
            logger.info(`[今日番剧] 准备推送到 ${this.BangumiConfig.PushGroupList.length} 个群组`)
            
            // 对每个群组，依次发送消息
            for (let i = 0; i < this.BangumiConfig.PushGroupList.length; i++) {
                setTimeout(async () => {
                    const group = Bot.pickGroup(this.BangumiConfig.PushGroupList[i])
                    if (!group) {
                        logger.error(`[今日番剧] 无法找到群组 ${this.BangumiConfig.PushGroupList[i]}`)
                        return
                    }
                    
                    logger.info(`[今日番剧] 正在向群组 ${group} 推送番剧。`)
                    
                    // 直接发送已渲染的图片
                    await group.sendMsg(image)
                    logger.info(`[今日番剧] 番剧已成功推送到群组 ${group}。`)
                }, i * 3000)
            }
        } catch (error) {
            logger.error('[今日番剧] 推送失败: ' + error.message)
        }
        
        return true
    }

    /**
     * 获取番剧数据
     * 优先从缓存获取，没有则从API获取
     * @param {string} type - 获取类型: 'today', 'yesterday', 'week', 'weekday:1'~'weekday:7'
     * @returns {Array} 番剧数据数组或分组数据
     */
    async getAnimeData(type = 'today') {
        // 缓存键名
        const cacheKey = `animeData:${type}`
        
        // 从Redis获取数据，如果没有则重新获取
        let animeDataJson = await redis.get(cacheKey)
        if (animeDataJson) {
            return JSON.parse(animeDataJson)
        }
        
        try {
            // 从API获取所有番剧日历数据
            let response = await fetch('https://api.bgm.tv/calendar')
            let data = await response.json()
            
            let now = new Date()
            let result = []
            
            // 判断是否是按特定星期查询
            const weekdayMatch = type.match(/^weekday:(\d)$/);
            
            // 根据类型筛选数据
            if (type === 'today') {
                // 今日番剧
                let weekday = (now.getDay() + 6) % 7 + 1 // 将星期日转换为7，星期一到星期六转换为1到6
                let items = data.find(item => item.weekday.id === weekday).items
                result = this.filterAnimeData(items)
            } else if (type === 'yesterday') {
                // 昨日番剧
                let yesterday = new Date(now)
                yesterday.setDate(yesterday.getDate() - 1)
                let weekday = (yesterday.getDay() + 6) % 7 + 1
                let items = data.find(item => item.weekday.id === weekday).items
                result = this.filterAnimeData(items)
            } else if (weekdayMatch) {
                // 特定星期的番剧
                const weekdayNum = parseInt(weekdayMatch[1]);
                let calendar = data.find(item => item.weekday.id === weekdayNum);
                if (!calendar) {
                    return [];
                }
                result = this.filterAnimeData(calendar.items);
            } else if (type === 'week') {
                // 本周番剧（所有天的番剧）- 按星期分组
                // 按星期ID排序（1-7，星期一到星期日）
                let sortedData = [...data].sort((a, b) => a.weekday.id - b.weekday.id);
                
                // 为每一天创建一个分组
                result = sortedData.map(calendar => {
                    // 过滤该天的番剧
                    let filteredItems = this.filterAnimeData(calendar.items);
                    
                    // 返回分组对象
                    return {
                        weekday: calendar.weekday.cn, // 中文星期名
                        weekdayId: calendar.weekday.id, // 星期ID
                        items: filteredItems // 该天的番剧列表
                    };
                }).filter(group => group.items.length > 0); // 过滤掉没有番剧的天
            }

            logger.info(`[番剧查询] 获取到 ${weekdayMatch ? `星期${['一','二','三','四','五','六','日'][parseInt(weekdayMatch[1])-1]}` : (type === 'week' ? '本周' : (type === 'today' ? '今日' : '昨日'))}番剧数据`)
            
            // 将获取到的数据存入Redis，设置不同的过期时间
            let expireTime = type === 'week' || type.startsWith('weekday:') ? 86400 : 14400 // 本周番剧和特定星期番剧缓存1天，其他4小时
            await redis.set(cacheKey, JSON.stringify(result), { EX: expireTime })
            
            return result
        } catch (error) {
            if (type.startsWith('weekday:')) {
                const weekdayNum = parseInt(type.split(':')[1]);
                const weekdayCN = `星期${['一','二','三','四','五','六','日'][weekdayNum-1]}`;
                logger.error(`[番剧查询] 获取${weekdayCN}番剧数据失败:`, error);
            } else {
                logger.error(`[番剧查询] 获取${type === 'today' ? '今日' : type === 'yesterday' ? '昨日' : '本周'}番剧数据失败:`, error);
            }
            throw error
        }
    }
    
    /**
     * 过滤番剧数据，确保必要字段存在
     * @param {Array} items - 原始番剧项目数组
     * @returns {Array} 过滤后的番剧数组
     */
    filterAnimeData(items) {
        return items.filter(item => {
            return (item.name_cn || item.name) && 
                  (item.images && item.images.common)
        })
    }
}
